home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dd / dbug_protos.h < prev    next >
Encoding:
Text File  |  1994-02-06  |  12.1 KB  |  325 lines
  1.  
  2. /* MACHINE GENERATED */
  3.  
  4.  
  5. /* umain.c              */
  6.  
  7.  
  8. /* lists.c              */
  9.  
  10. Prototype void    FreeDLIST(LIST *list);
  11. Prototype BOOL    AddListNODE(LIST *list, UBYTE type, char *data);
  12. Prototype BOOL    DownList(void);
  13. Prototype BOOL    UpList(void);
  14. Prototype BOOL    PageDownList(void);
  15. Prototype BOOL    PageUpList(void);
  16. Prototype WORD    RefreshList(WORD maxLines, BOOL fullRefresh, LONG top);
  17. Prototype BOOL    SprintfDLIST(LIST *list, UBYTE type, char *fmt, ...);
  18. Prototype void    ListDosBase(DBugDisp *dp);
  19. Prototype void    ListProcess(DBugDisp *dp);
  20. Prototype void    ListInfo(DBugDisp *dp);
  21. Prototype void    ListExecBase(DBugDisp *dp);
  22. Prototype void    BuildDLIST(LIST *dst, LIST *src, ULONG type);
  23. Prototype void    ListResources(DBugDisp *dp);
  24. Prototype void    ListIntrs(DBugDisp *dp);
  25. Prototype void    ListPorts(DBugDisp *dp);
  26. Prototype void    ListTasks(DBugDisp *dp);
  27. Prototype void    ListLibs(DBugDisp *dp);
  28. Prototype void    ListDevices(DBugDisp *dp);
  29. Prototype void    ListMemList(DBugDisp *dp);
  30. Prototype int     SizeDLIST(LIST *list);
  31. Prototype BOOL    ListSymbols(DBugDisp *dp);
  32.  
  33. /* dbug.c               */
  34.  
  35. Prototype void        Newline(void);
  36. Prototype void        PrintAddress(ULONG addr);
  37. Prototype void        OffsetAddressBuf(ULONG addr, char *buf);
  38. Prototype void        InitCommand(void);
  39. Prototype void        InitModes(void);
  40. Prototype void        RefreshCommand(int fullRefresh);
  41. Prototype void        RefreshPrompt(BOOL fullRefresh);
  42. Prototype void        RefreshWindow(int fullRefresh);
  43. Prototype void        RefreshAllWindows(int fullRefresh);
  44. Prototype void        SetDisplayMode(WORD, BOOL);
  45. Prototype void        ReadPrefs(void);
  46. Prototype void        WritePrefs(void);
  47. Prototype void        abort(void);
  48. Prototype BOOL        ParseArgToken(char *buf);
  49. Prototype ULONG     OnOffToggle(char *arg, ULONG val, ULONG mask);
  50. Prototype int        main(int ac, char *av[]);
  51. Prototype LONG        CalcDisplayLines(void);
  52. Prototype void        SetModeSave(WORD mode);
  53. Prototype ULONG        ValidMemCheck(ULONG address);
  54. Prototype __stkargs void kprintf(unsigned char *arg, ...);
  55. Prototype UBYTE     LineBuf[128];
  56. Prototype UBYTE     DirBuf[128];
  57. Prototype WORD        ForceFullRefresh;
  58. Prototype UBYTE     RexxReplyString[MAX_REXX_REPLY];
  59. Prototype UBYTE     DefaultPubName[128];
  60. Prototype char        lastCommand[128];
  61. Prototype int        RStepFlag;
  62. Prototype char        rexxhostname[16];
  63.  
  64. /* cexp.c               */
  65.  
  66. Prototype long        ParseExp(char *, short *, long);
  67. Prototype void        PushOp(short, short, short);
  68. Prototype int        TopOfOpStack(void);
  69. Prototype int        SecondOffOpStack(void);
  70. Prototype void        PushAtom(long, short);
  71.  
  72. /* commands.c           */
  73.  
  74. Prototype void        RefreshFKeys(BOOL fullRefresh);
  75. Prototype BOOL        FunctionKey(UWORD num);
  76. Prototype BOOL        HelpKey(void);
  77. Prototype BOOL         CmdFKey(char *args);
  78. Prototype BOOL        CmdRexx(char *args);
  79. Prototype BOOL        CmdSavePrefs(char *args);
  80. Prototype BOOL        CmdInfo(char *args);
  81. Prototype BOOL        CmdExecBase(char *args);
  82. Prototype BOOL        CmdResources(char *args);
  83. Prototype BOOL        CmdIntrs(char *args);
  84. Prototype BOOL        CmdPorts(char *args);
  85. Prototype BOOL        CmdSymList(char *args);
  86. Prototype BOOL        CmdTasks(char *args);
  87. Prototype BOOL        CmdLibs(char *args);
  88. Prototype BOOL        CmdDevices(char *args);
  89. Prototype BOOL        CmdMemList(char *args);
  90. Prototype BOOL        CmdDoBsBase(char *args);
  91. Prototype BOOL        CmdProcess(char *args);
  92. Prototype BOOL        CmdOffsets(char *args);
  93. Prototype BOOL        CmdDown(char *args);
  94. Prototype BOOL        CmdUp(char *args);
  95. Prototype BOOL        CmdPageDown(char *args);
  96. Prototype BOOL        CmdPageUp(char *args);
  97. Prototype BOOL        CmdSource(char *args);
  98. Prototype BOOL        CmdDism(char *args);
  99. Prototype BOOL        CmdMixed(char *args);
  100. Prototype BOOL        CmdBytes(char *args);
  101. Prototype BOOL        CmdWords(char *args);
  102. Prototype BOOL        CmdLongs(char *args);
  103. Prototype BOOL        CmdBreakpoint(char *args);
  104. Prototype BOOL        CmdBP(char *args);
  105. Prototype BOOL        CmdClear(char *args);
  106. Prototype BOOL        CmdHunks(char *args);
  107. Prototype BOOL        CmdSymbol(char *args);
  108. Prototype BOOL        CmdSet(char *args);
  109. Prototype BOOL        RStepTarget(void);
  110. Prototype BOOL        StepTarget(void);
  111. Prototype BOOL        StepTargetRange(ULONG addressLow, ULONG addressHi);
  112. Prototype BOOL        RStepTargetRange(ULONG addressLow, ULONG addressHi);
  113. Prototype BOOL        CmdStep(char *args);
  114. Prototype BOOL        CmdRStep(char *args);
  115. Prototype BOOL        OverTarget(void);
  116. Prototype BOOL        OverTargetRange(ULONG addressLow, ULONG addressHi);
  117. Prototype BOOL        CmdOver(char *args);
  118. Prototype BOOL        CmdReset(char *args);
  119. Prototype BOOL        GoTarget(void);
  120. Prototype BOOL        CmdGo(char *args);
  121. Prototype BOOL        CmdEval(char *args);
  122. Prototype BOOL        CmdOpen(char *args);
  123. Prototype BOOL        CmdClose(char *args);
  124. Prototype BOOL        CmdQuit(char *args);
  125. Prototype BOOL        CmdHelp(char *args) ;
  126. Prototype BOOL        CmdWatchBytes(char *args);
  127. Prototype BOOL        CmdWatchWords(char *args);
  128. Prototype BOOL        CmdWatchLongs(char *args);
  129. Prototype BOOL        CmdWatchClear(char *args);
  130. Prototype BOOL        CmdRefresh(char *args);
  131. Prototype BOOL        CmdDosBase(char *args);
  132. Prototype WORD        RefreshHelp(WORD maxLines, BOOL fullRefresh, LONG);
  133. Prototype BOOL        DownHelp(void);
  134. Prototype BOOL        UpHelp(void);
  135. Prototype int        HelpSize(void);
  136. Prototype char        *SkipBlanks(char *s);
  137. Prototype BOOL        DoCommand(char *command);
  138. Prototype BOOL        CmdAlias(char *args);
  139. Prototype BOOL        CmdUnAlias(char *args);
  140. Prototype BOOL        CmdRegs(char *args);
  141. Prototype BOOL        CmdJump(char *args);
  142. Prototype BOOL         CmdBar(char *args);
  143. Prototype BOOL         CmdEnd(char *args);
  144. Prototype BOOL         CmdItem(char *args);
  145. Prototype BOOL         CmdTitle(char *args);
  146. Prototype BOOL         CmdMenus(char *args);
  147. Prototype BOOL         CmdSubItem(char *args);
  148. Prototype BOOL         CmdChangeWindow(char *args);
  149. Prototype BOOL         CmdAgain(char *args);
  150. Prototype void         init_function_keys(void);
  151. Prototype char    fkeys[10][16];
  152. Prototype void kprintline(char *string);
  153. Prototype void kprintlen(char *string, int len);
  154.  
  155. /* loadseg.c            */
  156.  
  157. Prototype WORD        RefreshHunks(WORD maxLines, BOOL fullRefresh, LONG index);
  158. Prototype WORD        RefreshSymbols(WORD maxLines, BOOL fullRefresh, LONG index);
  159. Prototype LONG        SymbolIndexOfAddr(ULONG val);
  160. Prototype BOOL        DownHunks(void);
  161. Prototype BOOL        UpHunks(void);
  162. Prototype BOOL        DownSymbol(void);
  163. Prototype BOOL        PageDownSymbol(void);
  164. Prototype BOOL        UpSymbol(void);
  165. Prototype BOOL        PageUpSymbol(void);
  166. Prototype BOOL        DBugLoadSeg(char *filename);
  167. Prototype void        AllocateStack(void);
  168. Prototype void        ResetTarget(void);
  169. Prototype DEBUG     *FindDebug(ULONG address);
  170. Prototype DEBUG     *FindNearestDebug(ULONG address);
  171. Prototype SOURCE    *FindSource(DEBUG *debug, ULONG address);
  172. Prototype char        *FindSourceLine(DEBUG *debug, SOURCE *source);
  173. Prototype __stkargs char *LookupValue(ULONG value);
  174. Prototype ULONG     *NearestSymbol(ULONG value);
  175. Prototype char        *NearestValue(ULONG value);
  176. Prototype BOOL        LookupSymbol(char *symbol, ULONG *value);
  177. Prototype BOOL        LookupSymLen(char *symbol, UWORD len, ULONG *value);
  178. Prototype int        CountSymbols(void);
  179. Prototype void        CopySymbols(SYMLIST *symlist);
  180. Prototype char        *addscore(char *string);
  181. Prototype char        *addat(char *string);
  182.  
  183. /* breakpoints.c        */
  184.  
  185. Prototype WORD        RefreshBreakpoints(WORD maxLines, BOOL fullRefresh);
  186. Prototype BOOL        UpBreak(void);
  187. Prototype BOOL        DownBreak(void);
  188. Prototype void        InitBreakpoints(void);
  189. Prototype void        InstallBreakpoints(void);
  190. Prototype void        CheckBreakpoints(void);
  191. Prototype BOOL        IsBreakpoint(ULONG address);
  192. Prototype BOOL        SetBreakpoint(ULONG address, UWORD count, UWORD type);
  193. Prototype BOOL        ClearBreakpoint(ULONG address);
  194. Prototype void        SetTempBreakpoint(ULONG address);
  195. Prototype void        SetAllBreakpoints(void);
  196. Prototype WORD topBP;
  197.  
  198. /* hex.c                */
  199.  
  200. Prototype WORD        RefreshBytes(WORD maxLines, BOOL fullRefresh, ULONG addr);
  201. Prototype WORD        RefreshWords(WORD maxLines, BOOL fullRefresh, ULONG addr);
  202. Prototype WORD        RefreshLongs(WORD maxLines, BOOL fullRefresh, ULONG addr);
  203. Prototype BOOL        UpBytes(void);
  204. Prototype BOOL        UpWords(void);
  205. Prototype BOOL        UpLongs(void);
  206. Prototype BOOL        PageUpHex(void);
  207. Prototype BOOL        DownBytes(void);
  208. Prototype BOOL        DownWords(void);
  209. Prototype BOOL        DownLongs(void);
  210. Prototype BOOL        PageDownHex(void);
  211.  
  212. /* mixed.c              */
  213.  
  214. Prototype BOOL        DownMixed(void);
  215. Prototype BOOL        UpMixed(void);
  216. Prototype BOOL        PageDownMixed(void);
  217. Prototype BOOL        PageUpMixed(void);
  218. Prototype BOOL        DownSource(void);
  219. Prototype BOOL        UpSource(void);
  220. Prototype BOOL        PageDownSource(void);
  221. Prototype BOOL        PageUpSource(void);
  222. Prototype WORD        RefreshMixed(WORD maxLines, BOOL fullRefresh, ULONG, ULONG, WORD);
  223. Prototype WORD        PrevMixedLine(ULONG *addr, ULONG *line, LONG *info);
  224. Prototype WORD        NextMixedLine(ULONG *addr, ULONG *line, LONG *info);
  225. Prototype WORD        CurrentMixedLine(ULONG *addr, ULONG *line, LONG *info);
  226.  
  227. /* dism.c               */
  228.  
  229. Prototype BOOL        DownDism(void);
  230. Prototype BOOL        UpDism(void);
  231. Prototype BOOL        PageDownDism(void);
  232. Prototype BOOL        PageUpDism(void);
  233. Prototype WORD        RefreshDism(short maxLines, BOOL fullRefresh);
  234. Prototype ULONG     PreviousInstruction(ULONG addr);
  235.  
  236. /* registers.c          */
  237.  
  238. Prototype char        *StateText(ULONG staten);
  239. Prototype WORD        RefreshRegisters(WORD maxLines, BOOL fullRefresh);
  240. Prototype long        *RegisterAddress(char *name);
  241.  
  242. /* watchpoints.c        */
  243.  
  244. Prototype WORD        RefreshWatchpoints(WORD maxLines, BOOL fullRefresh);
  245. Prototype void        InitWatchpoints(void);
  246. Prototype BOOL        IsWatchpoint(char *expression);
  247. Prototype BOOL        SetWatchpoint(char *expression, ULONG type);
  248. Prototype BOOL        ClearWatchpoint(char *expression);
  249. Prototype BOOL         ShowWatchTitle(BOOL fullRefresh, WORD *count, WORD *maxLines);
  250.  
  251. /* menu.c               */
  252.  
  253. Prototype BOOL     enable_menus(void);
  254. Prototype void     init_default_menus(void);
  255. Prototype void     free_menus(void);
  256. Prototype void     set_menu_item(int num, int type, unsigned char *str, unsigned char *cmd, unsigned char *comkey);
  257. Prototype void     do_scroller(void);
  258. Prototype UWORD FindScrollerTop(UWORD total, UWORD displayable, UWORD pot);
  259. Prototype int     FindScrollerValues(UWORD total, UWORD displayable, UWORD top, WORD overlap, UWORD *body, UWORD *pot);
  260. Prototype void     setscrollbar(int flag);
  261. Prototype void     ActivateArrows(struct Window *win);
  262. Prototype void     InActivateArrows(struct Window *win);
  263. Prototype BOOL     ProcessMenuItem(char *args,int type);
  264. Prototype int    FindSlot(char *args);
  265. Prototype struct Menu *v_create_menus(struct NewMenu *menulist);
  266. Prototype int v_layout_menus(struct Menu *menus);
  267. Prototype void v_free_menus(struct Menu *menus);
  268. Prototype int text_width(char *str);
  269.  
  270. /* rexxfunc.c           */
  271.  
  272. Prototype BOOL        RXGetPC(char *args);
  273. Prototype BOOL        RXGetLine(char *args);
  274. Prototype BOOL        RXGetInfo(char *args);
  275. Prototype BOOL        RXGetDismLine(char *args);
  276. Prototype BOOL         RXGetEval(char *args);
  277. Prototype BOOL         RXGetBytes(char *args);
  278. Prototype BOOL        RXGetWords(char *args);
  279. Prototype BOOL        RXGetLongs(char *args);
  280. Prototype BOOL        RXGetCommand(char *args);
  281. Prototype BOOL        RXStartList(char *args);
  282. Prototype BOOL        RXEndList(char *args);
  283. Prototype BOOL        RXPutList(char *args);
  284.  
  285. /* console.c            */
  286.  
  287. Prototype void        InitConsole(void);
  288. Prototype LONG        ScrMainBodyRange(void *ptop, void *pbot);
  289. Prototype LONG        ScrColumns(WORD overhead, WORD itemWidth, WORD limit);
  290. Prototype void        ScrFlush(void);
  291. Prototype void        ScrPutNewline(void);
  292. Prototype void        ScrPutChar(UBYTE c);
  293. Prototype void        ScrWrite(char *s, ULONG len);
  294. Prototype void        ScrPuts(char *s);
  295. Prototype void        ScrPutsCtl(char *s);
  296. Prototype WORD        ScrPrintf(const char *fmt, ...);
  297. Prototype void        ScrStatus(const char *fmt, ...);
  298. Prototype void        ScrHome(void);
  299. Prototype void        ScrCursoff(void);
  300. Prototype void        ScrCurson(void);
  301. Prototype void        ScrClr(void);
  302. Prototype void        ScrRowCol(UWORD row, UWORD col);
  303. Prototype void        ScrEOL(void);
  304. Prototype void        ScrHighlight(void);
  305. Prototype void        ScrDull(void);
  306. Prototype void        ScrPlain(void);
  307. Prototype void        ScrInverse(void);
  308. Prototype void        ScrItalics(void);
  309. Prototype void        ScrUnderline(void);
  310. Prototype void        ScrScrollup(void);
  311. Prototype void        ScrScrolldown(void);
  312. Prototype DBugDisp     *ScrOpen(BOOL first, BOOL refresh, char *pubname);
  313. Prototype void        ScrScrollClr(void);
  314. Prototype void        GetWindowSize(void);
  315. Prototype void        EnterDebugger(void);
  316. Prototype void        CloseDisplay(struct DBugDisp *);
  317. Prototype void        RequestCloseDisplay(struct DBugDisp *, int );
  318. Prototype BOOL        CheckCloseDisplay(void);
  319. Prototype void        ProcessDataAtCoord(DBugDisp *disp, WORD x, WORD y);
  320. Prototype void         SetTitle(char *title, DBugDisp *disp);
  321. Prototype void         draw_fkey_boxes(void);
  322. Prototype void        drawdoublebox(void);
  323. Prototype struct DBugDisp  *CurDisplay;
  324. Prototype LIST    DisplayList;
  325.